/*
 * To change this template, choose Tools | Templates
 * and open the template in the editor.
 */
package Dao;

import Dao.exceptions.IllegalOrphanException;
import Dao.exceptions.NonexistentEntityException;
import Dao.exceptions.PreexistingEntityException;
import java.io.Serializable;
import javax.persistence.Query;
import javax.persistence.EntityNotFoundException;
import javax.persistence.criteria.CriteriaQuery;
import javax.persistence.criteria.Root;
import Logico.Evento;
import Logico.EspacioDeportivo;
import Logico.Disciplina;
import Logico.Usuario;
import java.util.ArrayList;
import java.util.List;
import Logico.Boleta;
import Logico.Competencia;
import Logico.DeportistaCompetencia;
import javax.persistence.EntityManager;
import javax.persistence.EntityManagerFactory;

/**
 *
 * @author usuario
 */
public class CompetenciaJpaController implements Serializable {

    public CompetenciaJpaController(EntityManagerFactory emf) {
        this.emf = emf;
    }
    protected EntityManagerFactory emf = null;

    public EntityManager getEntityManager() {
        return emf.createEntityManager();
    }

    public void create(Competencia competencia) throws PreexistingEntityException, Exception {
        if (competencia.getUsuarioList() == null) {
            competencia.setUsuarioList(new ArrayList<Usuario>());
        }
        if (competencia.getUsuarioList1() == null) {
            competencia.setUsuarioList1(new ArrayList<Usuario>());
        }
        if (competencia.getBoletaList() == null) {
            competencia.setBoletaList(new ArrayList<Boleta>());
        }
        if (competencia.getDeportistaCompetenciaList() == null) {
            competencia.setDeportistaCompetenciaList(new ArrayList<DeportistaCompetencia>());
        }
        EntityManager em = null;
        try {
            em = getEntityManager();
            em.getTransaction().begin();
            Evento eventoIdevento = competencia.getEventoIdevento();
            if (eventoIdevento != null) {
                eventoIdevento = em.getReference(eventoIdevento.getClass(), eventoIdevento.getIdevento());
                competencia.setEventoIdevento(eventoIdevento);
            }
            EspacioDeportivo idespacioDeportivo = competencia.getIdespacioDeportivo();
            if (idespacioDeportivo != null) {
                idespacioDeportivo = em.getReference(idespacioDeportivo.getClass(), idespacioDeportivo.getIdespacioDeportivo());
                competencia.setIdespacioDeportivo(idespacioDeportivo);
            }
            Disciplina disciplinaIddisciplina = competencia.getDisciplinaIddisciplina();
            if (disciplinaIddisciplina != null) {
                disciplinaIddisciplina = em.getReference(disciplinaIddisciplina.getClass(), disciplinaIddisciplina.getIddisciplina());
                competencia.setDisciplinaIddisciplina(disciplinaIddisciplina);
            }
            List<Usuario> attachedUsuarioList = new ArrayList<Usuario>();
            for (Usuario usuarioListUsuarioToAttach : competencia.getUsuarioList()) {
                usuarioListUsuarioToAttach = em.getReference(usuarioListUsuarioToAttach.getClass(), usuarioListUsuarioToAttach.getCedula());
                attachedUsuarioList.add(usuarioListUsuarioToAttach);
            }
            competencia.setUsuarioList(attachedUsuarioList);
            List<Usuario> attachedUsuarioList1 = new ArrayList<Usuario>();
            for (Usuario usuarioList1UsuarioToAttach : competencia.getUsuarioList1()) {
                usuarioList1UsuarioToAttach = em.getReference(usuarioList1UsuarioToAttach.getClass(), usuarioList1UsuarioToAttach.getCedula());
                attachedUsuarioList1.add(usuarioList1UsuarioToAttach);
            }
            competencia.setUsuarioList1(attachedUsuarioList1);
            List<Boleta> attachedBoletaList = new ArrayList<Boleta>();
            for (Boleta boletaListBoletaToAttach : competencia.getBoletaList()) {
                boletaListBoletaToAttach = em.getReference(boletaListBoletaToAttach.getClass(), boletaListBoletaToAttach.getIdboleteria());
                attachedBoletaList.add(boletaListBoletaToAttach);
            }
            competencia.setBoletaList(attachedBoletaList);
            List<DeportistaCompetencia> attachedDeportistaCompetenciaList = new ArrayList<DeportistaCompetencia>();
            for (DeportistaCompetencia deportistaCompetenciaListDeportistaCompetenciaToAttach : competencia.getDeportistaCompetenciaList()) {
                deportistaCompetenciaListDeportistaCompetenciaToAttach = em.getReference(deportistaCompetenciaListDeportistaCompetenciaToAttach.getClass(), deportistaCompetenciaListDeportistaCompetenciaToAttach.getDeportistaCompetenciaPK());
                attachedDeportistaCompetenciaList.add(deportistaCompetenciaListDeportistaCompetenciaToAttach);
            }
            competencia.setDeportistaCompetenciaList(attachedDeportistaCompetenciaList);
            em.persist(competencia);
            if (eventoIdevento != null) {
                eventoIdevento.getCompetenciaList().add(competencia);
                eventoIdevento = em.merge(eventoIdevento);
            }
            if (idespacioDeportivo != null) {
                idespacioDeportivo.getCompetenciaList().add(competencia);
                idespacioDeportivo = em.merge(idespacioDeportivo);
            }
            if (disciplinaIddisciplina != null) {
                disciplinaIddisciplina.getCompetenciaList().add(competencia);
                disciplinaIddisciplina = em.merge(disciplinaIddisciplina);
            }
            for (Usuario usuarioListUsuario : competencia.getUsuarioList()) {
                usuarioListUsuario.getCompetenciaList().add(competencia);
                usuarioListUsuario = em.merge(usuarioListUsuario);
            }
            for (Usuario usuarioList1Usuario : competencia.getUsuarioList1()) {
                usuarioList1Usuario.getCompetenciaList().add(competencia);
                usuarioList1Usuario = em.merge(usuarioList1Usuario);
            }
            for (Boleta boletaListBoleta : competencia.getBoletaList()) {
                Competencia oldCompetenciaIdcompetenciaOfBoletaListBoleta = boletaListBoleta.getCompetenciaIdcompetencia();
                boletaListBoleta.setCompetenciaIdcompetencia(competencia);
                boletaListBoleta = em.merge(boletaListBoleta);
                if (oldCompetenciaIdcompetenciaOfBoletaListBoleta != null) {
                    oldCompetenciaIdcompetenciaOfBoletaListBoleta.getBoletaList().remove(boletaListBoleta);
                    oldCompetenciaIdcompetenciaOfBoletaListBoleta = em.merge(oldCompetenciaIdcompetenciaOfBoletaListBoleta);
                }
            }
            for (DeportistaCompetencia deportistaCompetenciaListDeportistaCompetencia : competencia.getDeportistaCompetenciaList()) {
                Competencia oldCompetenciaOfDeportistaCompetenciaListDeportistaCompetencia = deportistaCompetenciaListDeportistaCompetencia.getCompetencia();
                deportistaCompetenciaListDeportistaCompetencia.setCompetencia(competencia);
                deportistaCompetenciaListDeportistaCompetencia = em.merge(deportistaCompetenciaListDeportistaCompetencia);
                if (oldCompetenciaOfDeportistaCompetenciaListDeportistaCompetencia != null) {
                    oldCompetenciaOfDeportistaCompetenciaListDeportistaCompetencia.getDeportistaCompetenciaList().remove(deportistaCompetenciaListDeportistaCompetencia);
                    oldCompetenciaOfDeportistaCompetenciaListDeportistaCompetencia = em.merge(oldCompetenciaOfDeportistaCompetenciaListDeportistaCompetencia);
                }
            }
            em.getTransaction().commit();
        } catch (Exception ex) {
            if (findCompetencia(competencia.getIdcompetencia()) != null) {
                throw new PreexistingEntityException("Competencia " + competencia + " already exists.", ex);
            }
            throw ex;
        } finally {
            if (em != null) {
                em.close();
            }
        }
    }

    public void edit(Competencia competencia) throws IllegalOrphanException, NonexistentEntityException, Exception {
        EntityManager em = null;
        try {
            em = getEntityManager();
            em.getTransaction().begin();
            Competencia persistentCompetencia = em.find(Competencia.class, competencia.getIdcompetencia());
            Evento eventoIdeventoOld = persistentCompetencia.getEventoIdevento();
            Evento eventoIdeventoNew = competencia.getEventoIdevento();
            EspacioDeportivo idespacioDeportivoOld = persistentCompetencia.getIdespacioDeportivo();
            EspacioDeportivo idespacioDeportivoNew = competencia.getIdespacioDeportivo();
            Disciplina disciplinaIddisciplinaOld = persistentCompetencia.getDisciplinaIddisciplina();
            Disciplina disciplinaIddisciplinaNew = competencia.getDisciplinaIddisciplina();
            List<Usuario> usuarioListOld = persistentCompetencia.getUsuarioList();
            List<Usuario> usuarioListNew = competencia.getUsuarioList();
            List<Usuario> usuarioList1Old = persistentCompetencia.getUsuarioList1();
            List<Usuario> usuarioList1New = competencia.getUsuarioList1();
            List<Boleta> boletaListOld = persistentCompetencia.getBoletaList();
            List<Boleta> boletaListNew = competencia.getBoletaList();
            List<DeportistaCompetencia> deportistaCompetenciaListOld = persistentCompetencia.getDeportistaCompetenciaList();
            List<DeportistaCompetencia> deportistaCompetenciaListNew = competencia.getDeportistaCompetenciaList();
            List<String> illegalOrphanMessages = null;
            for (Boleta boletaListOldBoleta : boletaListOld) {
                if (!boletaListNew.contains(boletaListOldBoleta)) {
                    if (illegalOrphanMessages == null) {
                        illegalOrphanMessages = new ArrayList<String>();
                    }
                    illegalOrphanMessages.add("You must retain Boleta " + boletaListOldBoleta + " since its competenciaIdcompetencia field is not nullable.");
                }
            }
            for (DeportistaCompetencia deportistaCompetenciaListOldDeportistaCompetencia : deportistaCompetenciaListOld) {
                if (!deportistaCompetenciaListNew.contains(deportistaCompetenciaListOldDeportistaCompetencia)) {
                    if (illegalOrphanMessages == null) {
                        illegalOrphanMessages = new ArrayList<String>();
                    }
                    illegalOrphanMessages.add("You must retain DeportistaCompetencia " + deportistaCompetenciaListOldDeportistaCompetencia + " since its competencia field is not nullable.");
                }
            }
            if (illegalOrphanMessages != null) {
                throw new IllegalOrphanException(illegalOrphanMessages);
            }
            if (eventoIdeventoNew != null) {
                eventoIdeventoNew = em.getReference(eventoIdeventoNew.getClass(), eventoIdeventoNew.getIdevento());
                competencia.setEventoIdevento(eventoIdeventoNew);
            }
            if (idespacioDeportivoNew != null) {
                idespacioDeportivoNew = em.getReference(idespacioDeportivoNew.getClass(), idespacioDeportivoNew.getIdespacioDeportivo());
                competencia.setIdespacioDeportivo(idespacioDeportivoNew);
            }
            if (disciplinaIddisciplinaNew != null) {
                disciplinaIddisciplinaNew = em.getReference(disciplinaIddisciplinaNew.getClass(), disciplinaIddisciplinaNew.getIddisciplina());
                competencia.setDisciplinaIddisciplina(disciplinaIddisciplinaNew);
            }
            List<Usuario> attachedUsuarioListNew = new ArrayList<Usuario>();
            for (Usuario usuarioListNewUsuarioToAttach : usuarioListNew) {
                usuarioListNewUsuarioToAttach = em.getReference(usuarioListNewUsuarioToAttach.getClass(), usuarioListNewUsuarioToAttach.getCedula());
                attachedUsuarioListNew.add(usuarioListNewUsuarioToAttach);
            }
            usuarioListNew = attachedUsuarioListNew;
            competencia.setUsuarioList(usuarioListNew);
            List<Usuario> attachedUsuarioList1New = new ArrayList<Usuario>();
            for (Usuario usuarioList1NewUsuarioToAttach : usuarioList1New) {
                usuarioList1NewUsuarioToAttach = em.getReference(usuarioList1NewUsuarioToAttach.getClass(), usuarioList1NewUsuarioToAttach.getCedula());
                attachedUsuarioList1New.add(usuarioList1NewUsuarioToAttach);
            }
            usuarioList1New = attachedUsuarioList1New;
            competencia.setUsuarioList1(usuarioList1New);
            List<Boleta> attachedBoletaListNew = new ArrayList<Boleta>();
            for (Boleta boletaListNewBoletaToAttach : boletaListNew) {
                boletaListNewBoletaToAttach = em.getReference(boletaListNewBoletaToAttach.getClass(), boletaListNewBoletaToAttach.getIdboleteria());
                attachedBoletaListNew.add(boletaListNewBoletaToAttach);
            }
            boletaListNew = attachedBoletaListNew;
            competencia.setBoletaList(boletaListNew);
            List<DeportistaCompetencia> attachedDeportistaCompetenciaListNew = new ArrayList<DeportistaCompetencia>();
            for (DeportistaCompetencia deportistaCompetenciaListNewDeportistaCompetenciaToAttach : deportistaCompetenciaListNew) {
                deportistaCompetenciaListNewDeportistaCompetenciaToAttach = em.getReference(deportistaCompetenciaListNewDeportistaCompetenciaToAttach.getClass(), deportistaCompetenciaListNewDeportistaCompetenciaToAttach.getDeportistaCompetenciaPK());
                attachedDeportistaCompetenciaListNew.add(deportistaCompetenciaListNewDeportistaCompetenciaToAttach);
            }
            deportistaCompetenciaListNew = attachedDeportistaCompetenciaListNew;
            competencia.setDeportistaCompetenciaList(deportistaCompetenciaListNew);
            competencia = em.merge(competencia);
            if (eventoIdeventoOld != null && !eventoIdeventoOld.equals(eventoIdeventoNew)) {
                eventoIdeventoOld.getCompetenciaList().remove(competencia);
                eventoIdeventoOld = em.merge(eventoIdeventoOld);
            }
            if (eventoIdeventoNew != null && !eventoIdeventoNew.equals(eventoIdeventoOld)) {
                eventoIdeventoNew.getCompetenciaList().add(competencia);
                eventoIdeventoNew = em.merge(eventoIdeventoNew);
            }
            if (idespacioDeportivoOld != null && !idespacioDeportivoOld.equals(idespacioDeportivoNew)) {
                idespacioDeportivoOld.getCompetenciaList().remove(competencia);
                idespacioDeportivoOld = em.merge(idespacioDeportivoOld);
            }
            if (idespacioDeportivoNew != null && !idespacioDeportivoNew.equals(idespacioDeportivoOld)) {
                idespacioDeportivoNew.getCompetenciaList().add(competencia);
                idespacioDeportivoNew = em.merge(idespacioDeportivoNew);
            }
            if (disciplinaIddisciplinaOld != null && !disciplinaIddisciplinaOld.equals(disciplinaIddisciplinaNew)) {
                disciplinaIddisciplinaOld.getCompetenciaList().remove(competencia);
                disciplinaIddisciplinaOld = em.merge(disciplinaIddisciplinaOld);
            }
            if (disciplinaIddisciplinaNew != null && !disciplinaIddisciplinaNew.equals(disciplinaIddisciplinaOld)) {
                disciplinaIddisciplinaNew.getCompetenciaList().add(competencia);
                disciplinaIddisciplinaNew = em.merge(disciplinaIddisciplinaNew);
            }
            for (Usuario usuarioListOldUsuario : usuarioListOld) {
                if (!usuarioListNew.contains(usuarioListOldUsuario)) {
                    usuarioListOldUsuario.getCompetenciaList().remove(competencia);
                    usuarioListOldUsuario = em.merge(usuarioListOldUsuario);
                }
            }
            for (Usuario usuarioListNewUsuario : usuarioListNew) {
                if (!usuarioListOld.contains(usuarioListNewUsuario)) {
                    usuarioListNewUsuario.getCompetenciaList().add(competencia);
                    usuarioListNewUsuario = em.merge(usuarioListNewUsuario);
                }
            }
            for (Usuario usuarioList1OldUsuario : usuarioList1Old) {
                if (!usuarioList1New.contains(usuarioList1OldUsuario)) {
                    usuarioList1OldUsuario.getCompetenciaList().remove(competencia);
                    usuarioList1OldUsuario = em.merge(usuarioList1OldUsuario);
                }
            }
            for (Usuario usuarioList1NewUsuario : usuarioList1New) {
                if (!usuarioList1Old.contains(usuarioList1NewUsuario)) {
                    usuarioList1NewUsuario.getCompetenciaList().add(competencia);
                    usuarioList1NewUsuario = em.merge(usuarioList1NewUsuario);
                }
            }
            for (Boleta boletaListNewBoleta : boletaListNew) {
                if (!boletaListOld.contains(boletaListNewBoleta)) {
                    Competencia oldCompetenciaIdcompetenciaOfBoletaListNewBoleta = boletaListNewBoleta.getCompetenciaIdcompetencia();
                    boletaListNewBoleta.setCompetenciaIdcompetencia(competencia);
                    boletaListNewBoleta = em.merge(boletaListNewBoleta);
                    if (oldCompetenciaIdcompetenciaOfBoletaListNewBoleta != null && !oldCompetenciaIdcompetenciaOfBoletaListNewBoleta.equals(competencia)) {
                        oldCompetenciaIdcompetenciaOfBoletaListNewBoleta.getBoletaList().remove(boletaListNewBoleta);
                        oldCompetenciaIdcompetenciaOfBoletaListNewBoleta = em.merge(oldCompetenciaIdcompetenciaOfBoletaListNewBoleta);
                    }
                }
            }
            for (DeportistaCompetencia deportistaCompetenciaListNewDeportistaCompetencia : deportistaCompetenciaListNew) {
                if (!deportistaCompetenciaListOld.contains(deportistaCompetenciaListNewDeportistaCompetencia)) {
                    Competencia oldCompetenciaOfDeportistaCompetenciaListNewDeportistaCompetencia = deportistaCompetenciaListNewDeportistaCompetencia.getCompetencia();
                    deportistaCompetenciaListNewDeportistaCompetencia.setCompetencia(competencia);
                    deportistaCompetenciaListNewDeportistaCompetencia = em.merge(deportistaCompetenciaListNewDeportistaCompetencia);
                    if (oldCompetenciaOfDeportistaCompetenciaListNewDeportistaCompetencia != null && !oldCompetenciaOfDeportistaCompetenciaListNewDeportistaCompetencia.equals(competencia)) {
                        oldCompetenciaOfDeportistaCompetenciaListNewDeportistaCompetencia.getDeportistaCompetenciaList().remove(deportistaCompetenciaListNewDeportistaCompetencia);
                        oldCompetenciaOfDeportistaCompetenciaListNewDeportistaCompetencia = em.merge(oldCompetenciaOfDeportistaCompetenciaListNewDeportistaCompetencia);
                    }
                }
            }
            em.getTransaction().commit();
        } catch (Exception ex) {
            String msg = ex.getLocalizedMessage();
            if (msg == null || msg.length() == 0) {
                Integer id = competencia.getIdcompetencia();
                if (findCompetencia(id) == null) {
                    throw new NonexistentEntityException("The competencia with id " + id + " no longer exists.");
                }
            }
            throw ex;
        } finally {
            if (em != null) {
                em.close();
            }
        }
    }

    public void destroy(Integer id) throws IllegalOrphanException, NonexistentEntityException {
        EntityManager em = null;
        try {
            em = getEntityManager();
            em.getTransaction().begin();
            Competencia competencia;
            try {
                competencia = em.getReference(Competencia.class, id);
                competencia.getIdcompetencia();
            } catch (EntityNotFoundException enfe) {
                throw new NonexistentEntityException("The competencia with id " + id + " no longer exists.", enfe);
            }
            List<String> illegalOrphanMessages = null;
            List<Boleta> boletaListOrphanCheck = competencia.getBoletaList();
            for (Boleta boletaListOrphanCheckBoleta : boletaListOrphanCheck) {
                if (illegalOrphanMessages == null) {
                    illegalOrphanMessages = new ArrayList<String>();
                }
                illegalOrphanMessages.add("This Competencia (" + competencia + ") cannot be destroyed since the Boleta " + boletaListOrphanCheckBoleta + " in its boletaList field has a non-nullable competenciaIdcompetencia field.");
            }
            List<DeportistaCompetencia> deportistaCompetenciaListOrphanCheck = competencia.getDeportistaCompetenciaList();
            for (DeportistaCompetencia deportistaCompetenciaListOrphanCheckDeportistaCompetencia : deportistaCompetenciaListOrphanCheck) {
                if (illegalOrphanMessages == null) {
                    illegalOrphanMessages = new ArrayList<String>();
                }
                illegalOrphanMessages.add("This Competencia (" + competencia + ") cannot be destroyed since the DeportistaCompetencia " + deportistaCompetenciaListOrphanCheckDeportistaCompetencia + " in its deportistaCompetenciaList field has a non-nullable competencia field.");
            }
            if (illegalOrphanMessages != null) {
                throw new IllegalOrphanException(illegalOrphanMessages);
            }
            Evento eventoIdevento = competencia.getEventoIdevento();
            if (eventoIdevento != null) {
                eventoIdevento.getCompetenciaList().remove(competencia);
                eventoIdevento = em.merge(eventoIdevento);
            }
            EspacioDeportivo idespacioDeportivo = competencia.getIdespacioDeportivo();
            if (idespacioDeportivo != null) {
                idespacioDeportivo.getCompetenciaList().remove(competencia);
                idespacioDeportivo = em.merge(idespacioDeportivo);
            }
            Disciplina disciplinaIddisciplina = competencia.getDisciplinaIddisciplina();
            if (disciplinaIddisciplina != null) {
                disciplinaIddisciplina.getCompetenciaList().remove(competencia);
                disciplinaIddisciplina = em.merge(disciplinaIddisciplina);
            }
            List<Usuario> usuarioList = competencia.getUsuarioList();
            for (Usuario usuarioListUsuario : usuarioList) {
                usuarioListUsuario.getCompetenciaList().remove(competencia);
                usuarioListUsuario = em.merge(usuarioListUsuario);
            }
            List<Usuario> usuarioList1 = competencia.getUsuarioList1();
            for (Usuario usuarioList1Usuario : usuarioList1) {
                usuarioList1Usuario.getCompetenciaList().remove(competencia);
                usuarioList1Usuario = em.merge(usuarioList1Usuario);
            }
            em.remove(competencia);
            em.getTransaction().commit();
        } finally {
            if (em != null) {
                em.close();
            }
        }
    }

    public List<Competencia> findCompetenciaEntities() {
        return findCompetenciaEntities(true, -1, -1);
    }

    public List<Competencia> findCompetenciaEntities(int maxResults, int firstResult) {
        return findCompetenciaEntities(false, maxResults, firstResult);
    }

    private List<Competencia> findCompetenciaEntities(boolean all, int maxResults, int firstResult) {
        EntityManager em = getEntityManager();
        try {
            CriteriaQuery cq = em.getCriteriaBuilder().createQuery();
            cq.select(cq.from(Competencia.class));
            Query q = em.createQuery(cq);
            if (!all) {
                q.setMaxResults(maxResults);
                q.setFirstResult(firstResult);
            }
            return q.getResultList();
        } finally {
            em.close();
        }
    }

    public Competencia findCompetencia(Integer id) {
        EntityManager em = getEntityManager();
        try {
            return em.find(Competencia.class, id);
        } finally {
            em.close();
        }
    }

    public int getCompetenciaCount() {
        EntityManager em = getEntityManager();
        try {
            CriteriaQuery cq = em.getCriteriaBuilder().createQuery();
            Root<Competencia> rt = cq.from(Competencia.class);
            cq.select(em.getCriteriaBuilder().count(rt));
            Query q = em.createQuery(cq);
            return ((Long) q.getSingleResult()).intValue();
        } finally {
            em.close();
        }
    }
    
}
